package innerclass_;

public class AnonymousInnerclass {
    public static void main(String[] args) {
         new Outer03().fun();
    }
}

interface IA{
    void cry();
}

class Tiger implements IA{
    @Override
    public void cry() {
        System.out.println("Tiger is crying ...");
    }
}
class Father{
    private String name;

    public Father(String name) {
        this.name = name;
    }

    public void say(){
        System.out.println(name+" is a father ! ...");
    }
}

abstract class Animal{
    abstract void cry();
}

class Outer03{
    public void fun(){
        //基于接口
        IA Tiger =new IA(){//匿名内部类，有对象名，没有类名（就好像接口实列化了一样）
            @Override
            public void cry() {
                System.out.println("Tiger Inner is crying ...");
            }
        };
        /*

        匿名内部类的实际运行类型 是 Outer03$1 //且这个类用一次就不会用第二次了，所有不需要类名，但是产生的对象可以跟正常对象一样的
        class Outer03$1 implements IA{
            @Override
            public void cry{
             System.out.println(" Tiger inner is crying ")
             }
        }

         */

        System.out.println("Tiger 的运行类型是 "+Tiger.getClass());
        Tiger.cry();
        Tiger.cry();
        Tiger.cry();
        //普通匿名内部类
        Father father=new Father("Jack"){
//            public void hh(){//不可以写新的方法
//                System.out.println("hhhhhh.....");
//            }

            @Override
            public void say() {//可以重写父类的方法，但不能写新的方法
                super.say();
                System.out.println("Override father's say() ...");
            }
        };
        father.say();

        System.out.println("father's class is "+father.getClass());
        /*底层机制
        class Outer03$2 extends Father{
            //这里可以重写方法，但不能写新的方法，写了也用不了
        }
         */

        Animal moneky = new Animal(){//基于抽象类的匿名内部类
            @Override
            void cry() {
                System.out.println("猴子嗷嗷叫。。。");
            }
        };
        moneky.cry();

    }
}